﻿using System;
using System.Windows;
using System.Windows.Input;
using personalplaner.business.stamm;
using personalplaner.common.mvvm;
using personalplaner.common.mvvm.commands;
using personalplaner.gui.stamm.viewmodels.models;
using System.Collections.ObjectModel;
using System.Collections.Generic;
using personalplaner.servicemodel.dataaccess;
using personalplaner.gui.common;
using personalplaner.business;

namespace personalplaner.gui.stamm.viewmodels
{
    public class SetPersonAbteilungViewModel : BaseViewModel
    {
		
        public SetPersonAbteilungViewModel(DependencyObject parent)
            : base(parent)
        {
        }

		public override void Loaded()
		{
			var mw = GetService<IMainWindowDisplayContainer>();
			mw.IsWaitVisible = false;
		}

        #region Commands

        ICommand _okcommand;
        public ICommand OkCommand
        {
            get
            {
                if (_okcommand == null)
                    _okcommand = new RelayCommand(OnOkCommand);
                return _okcommand;
            }
        }

        private void OnOkCommand(object parameter)
        {
            var wnd = Parent as Window;
            if (wnd != null)
            {
                wnd.DialogResult = true;
                wnd.Close();
                return;
            }

            var mw = GetService<IMainWindowDisplayContainer>();
            mw.MoveToPreviousView();
        }

        ICommand _cancelcommand;
        public ICommand CancelCommand
        {
            get
            {
                if (_cancelcommand == null)
                    _cancelcommand = new RelayCommand(OnCancelCommand);
                return _cancelcommand;
            }
        }

        private void OnCancelCommand(object parameter)
        {
            var wnd = Parent as Window;
            if (wnd != null)
            {
                wnd.DialogResult = false;
                wnd.Close();
                return;
            }

            var mw = GetService<IMainWindowDisplayContainer>();
            mw.MoveToPreviousView();
        }

		private ICommand _viewhistorycommand;
		public ICommand ViewHistoryCommand
		{
			get
			{
				if (_viewhistorycommand == null)
					_viewhistorycommand = new RelayCommand(OnViewHistory);
				return _viewhistorycommand;
			}
		}

		private void OnViewHistory(object parameter)
		{
			//CWA: implement the history viewer
		}

        private ICommand _deleteAbteilungCommand;
        public ICommand DeleteAbteilungCommand
        {
            get
            {
				if (_deleteAbteilungCommand == null)
                    _deleteAbteilungCommand = new RelayCommand<PersonAbteilung>(OnDeleteAbteilung);
				return _deleteAbteilungCommand;
            }
        }

        private void OnDeleteAbteilung(PersonAbteilung parameter)
        {
            if (MessageBox.Show(string.Format(Properties.Resources.AbteilungEntfernenQuestionFormat, parameter.Name, parameter.Von.ToShortDateString(), parameter.Bis.ToShortDateString()), Properties.Resources.AbteilungEntfernen, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
                return;

            var da = GetService<IAbteilungDataAccess>();
            da.DeletePersonAbteilung(PrsID, parameter.AbteilungID, parameter.Von, parameter.Bis);

            // refresh the data
            RefreshAbteilungen();
            //PersonAbteilungModel.AbteilungenZugeteilt.Clear();
            //var lst = da.GetPersonAbteilungen(PrsID, true, PersonAbteilungModel.Von);
            //foreach (PersonAbteilung itm in lst)
            //    PersonAbteilungModel.AbteilungenZugeteilt.Add(itm);

            //PersonAbteilungModel.AbteilungenNichtZugeteilt.Clear();
            //lst = da.GetPersonAbteilungen(PrsID, false, PersonAbteilungModel.Von);
            //foreach (var itm in lst)
            //    PersonAbteilungModel.AbteilungenNichtZugeteilt.Add(itm);


            AbteilungHistory.Clear();
            var hst = da.GetPersonAbteilungen(PrsID);
            foreach (var itm in hst)
                AbteilungHistory.Add(itm);

            var dap = GetService<IPensumDataAccess>();
            PersonAbteilungModel.MaxPensum = dap.GetPensumProzent(PrsID);

            RefreshPensumData();
        }
        

		private ICommand _addAbteilungCommand;
        public ICommand AddAbteilungCommand
        {
            get
            {
				if (_addAbteilungCommand == null)
                    _addAbteilungCommand = new RelayCommand(OnAddAbteilung, parameter => PersonAbteilungModel.AbteilungenZugeteilt.Count > 0);
				return _addAbteilungCommand;
            }
        }

        private void OnAddAbteilung(object parameter)
        {
            if (MessageBox.Show(Window.GetWindow(Parent), string.Format(Properties.Resources.AbteilungenZuweisenQuestionFormat, PersonAbteilungModel.Von.ToShortDateString()),
                Properties.Resources.AbteilungenZuweisen, MessageBoxButton.OKCancel, MessageBoxImage.Warning) != MessageBoxResult.OK)
                return;


            var da = GetService<IAbteilungDataAccess>();
            da.RemovePersonAbteilung(PrsID, 0, PersonAbteilungModel.Von, PersonAbteilungModel.Bis);

            foreach (var itm in PersonAbteilungModel.AbteilungenZugeteilt)
                if (itm.AbteilungID > 0 && itm.Prozent > 0)
                    da.SetPersonAbteilung(PrsID, itm.AbteilungID, PersonAbteilungModel.Von, PersonAbteilungModel.Bis, itm.Prozent);


            // refresh the data
            RefreshAbteilungen();
            //PersonAbteilungModel.AbteilungenZugeteilt.Clear();
            //var lst = da.GetPersonAbteilungen(PrsID, true, PersonAbteilungModel.Von);
            //foreach (var itm in lst)
            //    PersonAbteilungModel.AbteilungenZugeteilt.Add(itm);

            //PersonAbteilungModel.AbteilungenNichtZugeteilt.Clear();
            //lst = da.GetPersonAbteilungen(PrsID, false, PersonAbteilungModel.Von);
            //foreach (var itm in lst)
            //    PersonAbteilungModel.AbteilungenNichtZugeteilt.Add(itm);


            AbteilungHistory.Clear();
            var hst = da.GetPersonAbteilungen(PrsID);
            foreach (var itm in hst)
                AbteilungHistory.Add(itm);

            RefreshPensumData();
        }

        ICommand _addToListCommand;
        public ICommand AddToListCommand
        {
            get
            {
                if (_addToListCommand == null)
                    _addToListCommand = new RelayCommand(OnAddToList, parameter => PersonAbteilungModel.SelectedAbteilungNichtZugeteilt != null);
                return _addToListCommand;
            }
        }

        private void OnAddToList(object parameter)
        {
            if (PersonAbteilungModel.SelectedAbteilungNichtZugeteilt == null)
                return;

            if (PersonAbteilungModel.Pensum <= 0)
            {
                MessageBox.Show(Window.GetWindow(Parent), "Es wurde kein Pensum-Prozentsatz ausgewählt.\nBitte geben Sie ein Prozentsatz ein.", "Kein Prozentsatz", MessageBoxButton.OK);
                PersonAbteilungModel.RaiseMoveFocus("Pensum");
                return;
            }

            if (PersonAbteilungModel.IsValid)
            {
                if (PersonAbteilungModel.Von < PersonAbteilungModel.Bis)
                {
                    var abteilung = PersonAbteilungModel.SelectedAbteilungNichtZugeteilt;
                    PersonAbteilungModel.AbteilungenZugeteilt.Add(abteilung);
                    PersonAbteilungModel.AbteilungenNichtZugeteilt.Remove(abteilung);
                    abteilung.Prozent = PersonAbteilungModel.Pensum;
                    //PersonAbteilungModel.SelectedAbteilungNichtZugeteilt = null;
                    PersonAbteilungModel.Pensum = 0;

                    RefreshPensumData();
                }
            }
            else
            {
                MessageBox.Show(Window.GetWindow(Parent), "Ungültiger Pensum-Prozentsatz.\nBitte wälhlen Sie einen Prozentsatz zwischen 0 und " + PersonAbteilungModel.MaxPensum + " aus", "Ungültiger Prozentsatz", MessageBoxButton.OK);
                PersonAbteilungModel.RaiseMoveFocus("Pensum");
            }
        }

        ICommand _removeFromListCommand;
        public ICommand RemoveFromListCommand
        {
            get
            {
                if (_removeFromListCommand == null)
                    _removeFromListCommand = new RelayCommand(OnRemoveFromList, parameter => PersonAbteilungModel.SelectedAbteilungZugeteilt != null);
                return _removeFromListCommand;
            }
        }

        private void OnRemoveFromList(object parameter)
        {
            if (PersonAbteilungModel.SelectedAbteilungZugeteilt == null)
                return;

            var abteilung = PersonAbteilungModel.SelectedAbteilungZugeteilt;
            PersonAbteilungModel.AbteilungenZugeteilt.Remove(abteilung);
            PersonAbteilungModel.AbteilungenNichtZugeteilt.Add(abteilung);

            PersonAbteilungModel.Pensum = 0;

            RefreshPensumData();
        }

    	#endregion

        #region Implementation

        bool _updateAbteilungen;

        private void RefreshPensumData()
        {
            var dap = GetService<IPensumDataAccess>();
            var pens = dap.GetPensumProzent(PrsID, PersonAbteilungModel.Von);

            foreach (var itm in PersonAbteilungModel.AbteilungenZugeteilt)
                pens -= itm.Prozent;
            PersonAbteilungModel.MaxPensum = pens;
        }

        private void RefreshAbteilungen()
        {
            if (!_updateAbteilungen)
                return;

            var da = GetService<IAbteilungDataAccess>();
            PersonAbteilungModel.AbteilungenZugeteilt.Clear();
            var lst = da.GetPersonAbteilungen(PrsID, true, PersonAbteilungModel.Von);
            foreach (PersonAbteilung itm in lst)
                PersonAbteilungModel.AbteilungenZugeteilt.Add(itm);

            PersonAbteilungModel.AbteilungenNichtZugeteilt.Clear();
            lst = da.GetPersonAbteilungen(PrsID, false, PersonAbteilungModel.Von);
            foreach (var itm in lst)
                PersonAbteilungModel.AbteilungenNichtZugeteilt.Add(itm);
        }

        public override void Unload()
        {
            // use mediator to notify all suscribed methods that a person has to be updated
            Mediator.NotifyColleagues<int>("UpdatePersonAbteilung", PrsID);
        }

        #endregion

        #region Properties


        PersonAbteilungModel _personabteilungmodel;
		public PersonAbteilungModel PersonAbteilungModel
		{
			get
			{
                if (_personabteilungmodel == null)
                {
                    _personabteilungmodel = new PersonAbteilungModel();
                    _personabteilungmodel.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(abteilungmodelPropertyChanged);
                }
				return _personabteilungmodel;
			}
		}

        void abteilungmodelPropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            switch (e.PropertyName)
            {
                case "Von":
                case "Bis":
                    RefreshPensumData();
                    RefreshAbteilungen();
                    break;
            }
        }

		int _prsID;
        public int PrsID
        {
            get { return _prsID; }
            set
            {
                _prsID = value;
                RaisePropertyChanged("PrsID");

                //if (PersonAbteilungModel == null)
                //    PersonAbteilungModel = new PersonAbteilungModel();
                _updateAbteilungen = false;
				PersonAbteilungModel.Von = DateTime.Now;
				PersonAbteilungModel.Bis = DateTime.Now.AddYears(20);
                _updateAbteilungen = true;

                RefreshAbteilungen();

                var da = GetService<IAbteilungDataAccess>();

				AbteilungHistory.Clear();
				var hst = da.GetPersonAbteilungen(value);
				foreach (var itm in hst)
					AbteilungHistory.Add(itm);

				var dap = GetService<IPensumDataAccess>();
				PersonAbteilungModel.MaxPensum = dap.GetPensumProzent(value);

                RefreshPensumData();
            }
		}


		IList<PersonAbteilung> _history;
		public IList<PersonAbteilung> AbteilungHistory
		{
			get
			{
				if (_history == null)
					_history = new ObservableCollection<PersonAbteilung>();
				return _history;
			}
		}
		
		#endregion
	}
}
